import { defineStore } from 'pinia'
import { getProducts, createProduct, updateProduct, deleteProduct } from '@/api/product'
import { ElMessage } from 'element-plus'

export const useProductStore = defineStore('product', {
  state: () => ({
    products: [],
    total: 0
  }),

  actions: {
    // 获取商品列表
    async getProducts(params) {
      try {
        const isPaginationRequest = params && params.page && params.pageSize;
        const isGetAllData = params && params.getAllData === true;
        
        console.log('Store: 获取商品列表，参数:', params, 
                    '是否分页请求:', isPaginationRequest,
                    '是否获取所有数据:', isGetAllData);
        
        const res = await getProducts(params)
        console.log('Store: 商品列表响应:', res)

        if (res.code === 200) {
          // 处理不同的响应格式
          if (Array.isArray(res.data)) {
            this.products = res.data
            console.log('Store: 获取到数组格式的商品数据，条数:', res.data.length);
            
            // 如果直接返回数组，且请求中包含分页参数，则可能是后端没有正确处理分页
            // 此时需要手动计算总页数
            if (isPaginationRequest) {
              // 如果响应头中包含总数信息，优先使用
              const totalCount = res.headers?.['x-total-count'] || res.headers?.['X-Total-Count']
              if (totalCount) {
                this.total = parseInt(totalCount) || res.data.length
              } else {
                // 否则假设这是所有数据，设置总数
                this.total = Math.max(res.data.length, params.page * params.pageSize)
              }
              console.log('Store: 从数组响应计算总数:', this.total)
            } else {
              // 未使用分页，则总数就是返回的数组长度
              this.total = res.data.length
              console.log('Store: 未使用分页，总数设置为:', this.total)
            }
          } else if (res.data && res.data.records) {
            this.products = res.data.records
            this.total = res.data.total || res.data.records.length
            console.log('Store: 从分页响应获取总数:', this.total, '数据条数:', res.data.records.length)
          } else if (res.data) {
            this.products = [res.data]
            this.total = 1
            console.log('Store: 获取到单个商品数据')
          } else {
            this.products = []
            this.total = 0
            console.log('Store: 没有获取到商品数据')
          }
          
          // 对商品进行排序，确保按ID从小到大排序
          if (this.products.length > 0) {
            console.log('Store: 排序前商品ID列表:', this.products.map(p => p.productId || p.id).join(', '));
            
            // 显式转换ID为数字并严格排序
            this.products = [...this.products].sort((a, b) => {
              // 确保提取正确的ID字段并转为数字
              let idA = a.productId !== undefined ? Number(a.productId) : (a.id !== undefined ? Number(a.id) : 0);
              let idB = b.productId !== undefined ? Number(b.productId) : (b.id !== undefined ? Number(b.id) : 0);
              
              // 确保是数字类型
              idA = isNaN(idA) ? 0 : idA;
              idB = isNaN(idB) ? 0 : idB;
              
              // 如果不是分页请求，打印更详细的排序信息
              if (isGetAllData) {
                console.log(`Store: 比较ID: ${idA} vs ${idB} = ${idA - idB}`);
              }
              
              return idA - idB; // 升序排列
            });
            
            console.log('Store: 排序后商品ID列表:', this.products.map(p => p.productId || p.id).join(', '));
            
            // 检查排序结果是否正确
            const sortedIds = this.products.map(p => Number(p.productId || p.id));
            const isSorted = sortedIds.every((id, i) => i === 0 || id > sortedIds[i - 1]);
            console.log('Store: 排序是否正确:', isSorted);
            
            if (!isSorted) {
              console.warn('Store: 警告: 排序可能不正确，请检查数据');
            }
          }
          
          return res.data
        }
        throw new Error(res.message || '获取商品列表失败')
      } catch (error) {
        console.error('Store: 获取商品列表失败:', error)
        ElMessage.error(error.message || '获取商品列表失败')
        this.products = []
        this.total = 0
        throw error
      }
    },

    // 创建商品
    async createProduct(data) {
      try {
        console.log('创建商品，数据:', data)
        const res = await createProduct(data)
        if (res.code === 200) {
          ElMessage.success('创建商品成功')
          await this.getProducts()
          return res.data
        }
        throw new Error(res.message || '创建商品失败')
      } catch (error) {
        console.error('创建商品失败:', error)
        ElMessage.error(error.message || '创建商品失败')
        throw error
      }
    },

    // 更新商品
    async updateProduct(data) {
      try {
        console.log('更新商品，数据:', data)
        const id = data.id || data.productId
        if (!id) {
          throw new Error('商品ID不能为空')
        }
        const res = await updateProduct(id, data)
        if (res.code === 200) {
          ElMessage.success('更新商品成功')
          await this.getProducts()
          return res.data
        }
        throw new Error(res.message || '更新商品失败')
      } catch (error) {
        console.error('更新商品失败:', error)
        ElMessage.error(error.message || '更新商品失败')
        throw error
      }
    },

    // 删除商品
    async deleteProduct(id) {
      try {
        console.log('删除商品，ID:', id)
        const res = await deleteProduct(id)
        if (res.code === 200) {
          ElMessage.success('删除商品成功')
          await this.getProducts()
          return res.data
        }
        throw new Error(res.message || '删除商品失败')
      } catch (error) {
        console.error('删除商品失败:', error)
        ElMessage.error(error.message || '删除商品失败')
        throw error
      }
    }
  }
}) 